package apipractice;

import object.Point;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 *
 */
public class SortInteger {
    public static void main(String[] args) {
        /**1集合排序*/
        Random rand = new Random();
        List<Integer> a = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            a.add(rand.nextInt(100));
        }
        System.out.println("原始数据" + a);
        Collections.sort(a);
        System.out.println("排序后数据" + a);
        Collections.reverse(a);
        System.out.println("排序反转" + a);
        System.out.println(a.get(0));


        List<String> b = new ArrayList<>();
        b.add("hhh");
        b.add("dxg");
        b.add("dhz");
        b.add("jgv");
        b.add("detgsd");
        System.out.println("b集合原始数据" + b);
        //对英文字符串排序时，会按首字母的ASCII码来排
        // 若首字母相同，则比较第2个字母的ASCII码，以此类推
        Collections.sort(b);
        System.out.println("b集合排序数据" + b);


        List<String> c = new ArrayList<>();
        c.add("飞机");
        c.add("战斗机");
        c.add("王炸");
        c.add("超级加倍");
        c.add("抢地主");
        System.out.println("c原始数据" + c);
        Collections.sort(c);//ASCII码
        System.out.println("c排序数据" + c);
        Collections.sort(c, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        System.out.println("C的字符长度排序" + c);


        Collections.sort(b, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        System.out.println("b的字符长度排序" + b);


        List<Point> d = new ArrayList<>();
        d.add(new Point(10, 2));
        d.add(new Point(65, 4));
        d.add(new Point(34, 8));
        d.add(new Point(37, 2));

        System.out.println("d集合原始数据" + d);
        Collections.sort(d, new Comparator<Point>() {
            @Override
            public int compare(Point o1, Point o2) {
                return o1.getX() - o2.getX();
            }
        });
        System.out.println("d集合排序数据" + d);



        /**
         *2 Lambda表达式（jdk1.8）
         * */
        List<String>e=new ArrayList<>();
        //匿名内部内写法
        Collections.sort(e, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });

        //lambda表达式写法
        Collections.sort(e,(String o1, String o2)-> {
                return o1.length()-o2.length();
            }
        );
        //lambda表达式参数类型可以不写
        Collections.sort(e,( o1,  o2)-> {
                    return o1.length()-o2.length();
                }
        );
        //方法体中若只有一句话，return可不写
        Collections.sort(e,( o1,  o2)-> o1.length()-o2.length());

        /**
         *3.Map双列集合
         * */
        Map<String,Integer>f=new LinkedHashMap<>();
        f.put("语文",90);
        f.put("数学",80);
        f.put("英语",70);
        f.put("政治",60);
        f.put("历史",100);
        System.out.println("f原始数据"+f);
        Integer value=f.put("数学",70);
        System.out.println(value);
        System.out.println("修改数学后"+f);
        value=f.put("化学",30);
        System.out.println(value);
        System.out.println(f);
        Integer size=f.size();
        //size集合数据条数
        System.out.println("集合数据条数"+size);
        //isEmpty判断集合是否为空
        System.out.println("判断集合是否为空"+f.isEmpty());
        //containsKey判断集合是否包含这个键
        System.out.println("判断集合是否包含这个键"+f.containsKey("数学"));
        //containsValue判断集合是否包含这个值
        System.out.println("判断集合是否包含这个值"+f.containsValue(90));
        //remove删除
        f.remove("语文");
        System.out.println("删除语文后"+f);
        f.clear();//清除集合内容

        /**
         * LinkedHashMap
         * */
        //10为数据初始值，0.75F为扩容因子，true为记录访问顺序
        HashMap<String,Integer>g=new LinkedHashMap<>(10,0.75F,true);
        g.put("语文",90);
        g.put("数学",80);
        g.put("英语",80);
        g.put("历史",80);
        g.put("地理",80);
        System.out.println("原始数据"+g);
        Integer values=g.get("数学");
        System.out.println(values);
        System.out.println("访问数学后"+g);

        /**Map的三种遍历*/
        Map<String,Integer>h=new HashMap<>();
        h.put("语文",90);
        h.put("数学",80);
        h.put("英语",80);
        h.put("历史",80);
        h.put("地理",80);
        //遍历所有的key用Set
        Set<String>keySet=h.keySet();
        for (String key:keySet){
            System.out.println("key"+key);
        }
        //遍历所有的value用Collection
        Collection<Integer>valueSet=h.values();
        for (Integer value1:valueSet){
            System.out.println("value"+value1);
        }
        //遍历键值对（Entry）用Set
        Set<Map.Entry<String,Integer>>EntrySet=h.entrySet();
        for (Map.Entry<String,Integer>en:EntrySet){
            String key=en.getKey();
            Integer value2=en.getValue();
            System.out.println(key+value2);
        }
        /**
         * forEach遍历集合
         * */
        Set<String>keset=h.keySet();
        keset.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("forEach获取键"+s);
            }
        });
        Collection<Integer>value3set=h.values();
        value3set.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println("forEach获取值"+integer);
            }
        });
        h.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+","+integer);
            }
        });
    }
}
